home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / hiddev.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  7KB  |  243 lines
  1. #ifndef _HIDDEV_H
  2. #define _HIDDEV_H
  3.  
  4. /*
  5.  * $Id: hiddev.h,v 1.2 2001/04/26 11:26:09 vojtech Exp $
  6.  *
  7.  *  Copyright (c) 1999-2000 Vojtech Pavlik
  8.  *
  9.  *  Sponsored by SuSE
  10.  */
  11.  
  12. /*
  13.  * This program is free software; you can redistribute it and/or modify
  14.  * it under the terms of the GNU General Public License as published by
  15.  * the Free Software Foundation; either version 2 of the License, or 
  16.  * (at your option) any later version.
  17.  * 
  18.  * This program is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  * GNU General Public License for more details.
  22.  * 
  23.  * You should have received a copy of the GNU General Public License
  24.  * along with this program; if not, write to the Free Software
  25.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  26.  * 
  27.  * Should you need to contact me, the author, you can do so either by
  28.  * e-mail - mail your message to <vojtech@suse.cz>, or by paper mail:
  29.  * Vojtech Pavlik, Ucitelska 1576, Prague 8, 182 00 Czech Republic
  30.  */
  31.  
  32. /*
  33.  * The event structure itself
  34.  */
  35.  
  36. #define HID_MAX_USAGES 1024 /* From: drivers/usb/input/hid.h */
  37.  
  38. struct hiddev_event {
  39.     unsigned hid;
  40.     signed int value;
  41. };
  42.  
  43. struct hiddev_devinfo {
  44.     __u32 bustype;
  45.     __u32 busnum;
  46.     __u32 devnum;
  47.     __u32 ifnum;
  48.     __s16 vendor;
  49.     __s16 product;
  50.     __s16 version;
  51.     __u32 num_applications;
  52. };
  53.  
  54. struct hiddev_collection_info {
  55.     __u32 index;
  56.     __u32 type;
  57.     __u32 usage;
  58.     __u32 level;
  59. };
  60.  
  61. #define HID_STRING_SIZE 256
  62. struct hiddev_string_descriptor {
  63.     __s32 index;
  64.     char value[HID_STRING_SIZE];
  65. };
  66.  
  67. struct hiddev_report_info {
  68.     __u32 report_type;
  69.     __u32 report_id;
  70.     __u32 num_fields;
  71. };
  72.  
  73. /* To do a GUSAGE/SUSAGE, fill in at least usage_code,  report_type and 
  74.  * report_id.  Set report_id to REPORT_ID_UNKNOWN if the rest of the fields 
  75.  * are unknown.  Otherwise use a usage_ref struct filled in from a previous 
  76.  * successful GUSAGE call to save time.  To actually send a value to the
  77.  * device, perform a SUSAGE first, followed by a SREPORT.  An INITREPORT or a
  78.  * GREPORT isn't necessary for a GUSAGE to return valid data.
  79.  */
  80. #define HID_REPORT_ID_UNKNOWN 0xffffffff
  81. #define HID_REPORT_ID_FIRST   0x00000100
  82. #define HID_REPORT_ID_NEXT    0x00000200
  83. #define HID_REPORT_ID_MASK    0x000000ff
  84. #define HID_REPORT_ID_MAX     0x000000ff
  85.  
  86. #define HID_REPORT_TYPE_INPUT    1
  87. #define HID_REPORT_TYPE_OUTPUT    2
  88. #define HID_REPORT_TYPE_FEATURE    3
  89. #define HID_REPORT_TYPE_MIN     1
  90. #define HID_REPORT_TYPE_MAX     3
  91.  
  92. struct hiddev_field_info {
  93.     __u32 report_type;
  94.     __u32 report_id;
  95.     __u32 field_index;
  96.     __u32 maxusage;
  97.     __u32 flags;
  98.     __u32 physical;        /* physical usage for this field */
  99.     __u32 logical;        /* logical usage for this field */
  100.     __u32 application;        /* application usage for this field */
  101.     __s32 logical_minimum;
  102.     __s32 logical_maximum;
  103.     __s32 physical_minimum;
  104.     __s32 physical_maximum;
  105.     __u32 unit_exponent;
  106.     __u32 unit;
  107. };
  108.  
  109. /* Fill in report_type, report_id and field_index to get the information on a
  110.  * field.
  111.  */
  112. #define HID_FIELD_CONSTANT        0x001
  113. #define HID_FIELD_VARIABLE        0x002
  114. #define HID_FIELD_RELATIVE        0x004
  115. #define HID_FIELD_WRAP            0x008    
  116. #define HID_FIELD_NONLINEAR        0x010
  117. #define HID_FIELD_NO_PREFERRED        0x020
  118. #define HID_FIELD_NULL_STATE        0x040
  119. #define HID_FIELD_VOLATILE        0x080
  120. #define HID_FIELD_BUFFERED_BYTE        0x100
  121.  
  122. struct hiddev_usage_ref {
  123.     __u32 report_type;
  124.     __u32 report_id;
  125.     __u32 field_index;
  126.     __u32 usage_index;
  127.     __u32 usage_code;
  128.     __s32 value;
  129. };
  130.  
  131. /* hiddev_usage_ref_multi is used for sending multiple bytes to a control.
  132.  * It really manifests itself as setting the value of consecutive usages */
  133. #define HID_MAX_MULTI_USAGES 1024
  134. struct hiddev_usage_ref_multi {
  135.     struct hiddev_usage_ref uref;
  136.     __u32 num_values;
  137.     __s32 values[HID_MAX_MULTI_USAGES];
  138. };
  139.  
  140. /* FIELD_INDEX_NONE is returned in read() data from the kernel when flags
  141.  * is set to (HIDDEV_FLAG_UREF | HIDDEV_FLAG_REPORT) and a new report has
  142.  * been sent by the device 
  143.  */
  144. #define HID_FIELD_INDEX_NONE 0xffffffff
  145.  
  146. /*
  147.  * Protocol version.
  148.  */
  149.  
  150. #define HID_VERSION        0x010004
  151.  
  152. /*
  153.  * IOCTLs (0x00 - 0x7f)
  154.  */
  155.  
  156. #define HIDIOCGVERSION        _IOR('H', 0x01, int)
  157. #define HIDIOCAPPLICATION    _IO('H', 0x02)
  158. #define HIDIOCGDEVINFO        _IOR('H', 0x03, struct hiddev_devinfo)
  159. #define HIDIOCGSTRING        _IOR('H', 0x04, struct hiddev_string_descriptor)
  160. #define HIDIOCINITREPORT    _IO('H', 0x05)
  161. #define HIDIOCGNAME(len)    _IOC(_IOC_READ, 'H', 0x06, len)
  162. #define HIDIOCGREPORT        _IOW('H', 0x07, struct hiddev_report_info)
  163. #define HIDIOCSREPORT        _IOW('H', 0x08, struct hiddev_report_info)
  164. #define HIDIOCGREPORTINFO    _IOWR('H', 0x09, struct hiddev_report_info)
  165. #define HIDIOCGFIELDINFO    _IOWR('H', 0x0A, struct hiddev_field_info)
  166. #define HIDIOCGUSAGE        _IOWR('H', 0x0B, struct hiddev_usage_ref)
  167. #define HIDIOCSUSAGE        _IOW('H', 0x0C, struct hiddev_usage_ref)
  168. #define HIDIOCGUCODE        _IOWR('H', 0x0D, struct hiddev_usage_ref)
  169. #define HIDIOCGFLAG        _IOR('H', 0x0E, int)
  170. #define HIDIOCSFLAG        _IOW('H', 0x0F, int)
  171. #define HIDIOCGCOLLECTIONINDEX    _IOW('H', 0x10, struct hiddev_usage_ref)
  172. #define HIDIOCGCOLLECTIONINFO    _IOWR('H', 0x11, struct hiddev_collection_info)
  173. #define HIDIOCGPHYS(len)    _IOC(_IOC_READ, 'H', 0x12, len)
  174.  
  175. /* For writing/reading to multiple/consecutive usages */
  176. #define HIDIOCGUSAGES        _IOWR('H', 0x13, struct hiddev_usage_ref_multi)
  177. #define HIDIOCSUSAGES        _IOW('H', 0x14, struct hiddev_usage_ref_multi)
  178.  
  179. /* 
  180.  * Flags to be used in HIDIOCSFLAG
  181.  */
  182. #define HIDDEV_FLAG_UREF    0x1
  183. #define HIDDEV_FLAG_REPORT    0x2
  184. #define HIDDEV_FLAGS        0x3
  185.  
  186. /* To traverse the input report descriptor info for a HID device, perform the 
  187.  * following:
  188.  *
  189.  *  rinfo.report_type = HID_REPORT_TYPE_INPUT;
  190.  *  rinfo.report_id = HID_REPORT_ID_FIRST;
  191.  *  ret = ioctl(fd, HIDIOCGREPORTINFO, &rinfo);
  192.  *
  193.  *  while (ret >= 0) {
  194.  *      for (i = 0; i < rinfo.num_fields; i++) { 
  195.  *        finfo.report_type = rinfo.report_type;
  196.  *          finfo.report_id = rinfo.report_id;
  197.  *          finfo.field_index = i;
  198.  *          ioctl(fd, HIDIOCGFIELDINFO, &finfo);
  199.  *          for (j = 0; j < finfo.maxusage; j++) {
  200.  *              uref.field_index = i;
  201.  *        uref.usage_index = j;
  202.  *        ioctl(fd, HIDIOCGUCODE, &uref);
  203.  *        ioctl(fd, HIDIOCGUSAGE, &uref);
  204.  *          }
  205.  *    }
  206.  *    uref.report_id |= HID_REPORT_ID_NEXT;
  207.  *    ret = ioctl(fd, HIDIOCGREPORTINFO, &uref);
  208.  *  }
  209.  */
  210.  
  211.  
  212. #ifdef __KERNEL__
  213.  
  214. /*
  215.  * In-kernel definitions.
  216.  */
  217.  
  218. struct hid_device;
  219. struct hid_usage;
  220. struct hid_field;
  221. struct hid_report;
  222.  
  223. #ifdef CONFIG_USB_HIDDEV
  224. int hiddev_connect(struct hid_device *);
  225. void hiddev_disconnect(struct hid_device *);
  226. void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
  227.               struct hid_usage *usage, __s32 value, struct pt_regs *regs);
  228. void hiddev_report_event(struct hid_device *hid, struct hid_report *report);
  229. int __init hiddev_init(void);
  230. void hiddev_exit(void);
  231. #else
  232. static inline int hiddev_connect(struct hid_device *hid) { return -1; }
  233. static inline void hiddev_disconnect(struct hid_device *hid) { }
  234. static inline void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
  235.               struct hid_usage *usage, __s32 value, struct pt_regs *regs) { }
  236. static inline void hiddev_report_event(struct hid_device *hid, struct hid_report *report) { }
  237. static inline int hiddev_init(void) { return 0; }
  238. static inline void hiddev_exit(void) { }
  239. #endif
  240.  
  241. #endif
  242. #endif
  243.